MUM 2024-25 modele konwolucyjne

import math
import torch
from torch import nn
from d2l import torch as d2l
import matplotlib
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline 

• modele typu MLPokazują się bardzo nieefektywne przy danych tablicowych
  • obraz 1000 na 1000 z 1000 na 1000 neuronów w warstwie ukrytej będzie już od razu miał $10^{12}$ parametrów
  • architektura kompletnie nie wykorzystuje redundancji obrazów (danych)
    • inwariancja ze względu na translację, obrót
    • MLP nie wykorzystuje lokalności cech danych

konwolucje

• niech sieć (MLP) "każdy z każdym" ma 2-wymiarowe wejściowe obrazy $X$ (indeksowane przez k, l) oraz ukryte reprezentacje $H$ (indeksowane i, j) $$\begin{align} [H]_{ij}&=[U]_{ij}+\sum_k\sum_l[W]_{ijkl}[X]_{kl}\\ &=[U]_{ij}+\sum_a\sum_b[V]_{ijab}[X]_{i+a,j+b} \end{align}$$
  • zamiana W na V to tylko przeindeksowanie $[W]_{(ij)(kl)}=[V]_{i, j, i+a, j+b}$
  • W jest 4-wymiarowym tensorem
• niezależność ze względu na translację: niech macierz $[V]$ będzie niezależna od położenia i przesunięcie wejścia powoduje przesunięcie wartości ukrytej $$[H]_{ij}=u+\sum_a\sum_b[V]_{ab}[X]_{i+a,j+b}$$

  • wartość $u$ jest wobec tego skalarem niezależnym od położenia

  • w ten sposób mamy konwolucję $$(f\ast{}g)(x)=\int{}f(z)g(x-z)dz$$

    • dla obrazów w postaci dyskretnej mamy $$(f\ast{}g)(i)=\sum_a f(a)g(i-a)$$ lub dla dwuwymiarowych $$(f\ast{}g)(i,j)=\sum_a\sum_b f(a,b)g(i-a,j-b)$$

  • dla $a,b\in(-1000, 1000)$ dostajemy $4\times10^6$ parametrów

  • tak zdefiniowane konwolucje powinny być zwane kross-korelacjami

lokalność

• kolejnym założeniem jest, że wartość $[H]_{ij}$ powinna być zależna jedynie od niewielu punktów w otoczeniu $[X]_{ij}$ $$[H]_{ij}=u+\sum_{-\Delta}^{+\Delta}\sum_{-\Delta}^{+\Delta}[V]_{ab}[X]_{i+a,j+b}$$
  • to ogranicza liczbę parametrów do $4\times\Delta^2$
    • $\Delta$ jest tu użyta jako promień
    • $\Delta$ nie musi być identyczna w każdym wymiarze
    • liczba wymiarów może być różna: jeden (szereg czasowy), dwa (po prostu obraz w $\mathbb{R}^2$, trzy (obraz ale z kilkoma kanałami kolorów), cztery (plus czas, np. film)
  • $[V]$ nazywamy zwykle kernelem
  • mamy bardzo ograniczoną liczbę parametrów
  • parametry są dzielone (shared), a więc uczą się wykrywania tych samych cech w różnych częściach wejścia

kanały

• w przypadku obrazów każdy piksel jest zwykle złożony z trzech kolorów -- kanałów

  • macierz parametrów staje się trójwymiarowa $[V]_{a,b,c}$
  • dla każdego położenia będziemy mieli cały wektor reprezentacji o indeksowany przez $d$, tworzący nowy kanał w reprezentacji ukrytej $$[H]_{ijd}=\sum_{-\Delta}^{+\Delta}\sum_{-\Delta}^{+\Delta}\sum_c[V]_{abcd}[X]_{i+a,j+b,c}$$ dając trzeci wymiar $H$
  • oczywiście nie tylko kolory są legalnymi kanałami
    • rzeczywiste obrazy są tworzone w bardzo wielu kanałach odpowiadających różnym częstotliwościom
    • w szczególności utworzone powyżej reprezentacje też generują kanały

• konwolucje przez dzielenie wag ograniczają liczbę parametrów

• w dalszym ciągu bardzo wysoka jest liczba koniecznych obliczeń rzędu $O(h\cdot w\cdot k^2\cdot{}c_{in}\cdot{}c_{out})$ dla konwolucji $k\times{}k$

padding, stride, dilation

• obliczając cross-correlation obrazu z kernelem konwolucji, zwykle
  • zaczynamy od lewego górnego, kończymy na prawym dolnym rogu,
  • przesunięcie o jeden w poziomie i pionie

co powoduje zredukowanie informacji o brzegach oraz zmniejszenie obrazu

padding

---

• dodanie kolumn i wierszy po wszystkich stronach
  • dodaje kontrolę nad wymiarem
  • zachowanie informacji o brzegach
  • zwykle zera na dodanych pozycjach — algorytm może wiedzieć gdzie "zaczynają" się zera bez ich fizycznej reprezentacji
    • padding nie musi być wypełniony zerami, ale nie ma jasnych wskazówek kiedy
  • zapewnia, że wszystkie piksele są używane równie często

stride

---

• przeskok obliczeń co ustaloną liczbę wierszy / kolumn
• zwykle, jak padding, takie same w poziomie i pionie
• forma downsamplingu dla efektywności
  • szczególnie gdy same konwolucje są duże

dilation

---

• dodanie przerw co ustaloną liczbę kolumn/wierszy
  • dylacja k oznacza opuszczenie k-1 wierszy / kolumn
• zwykle przy pozostawionym stride, niekoniecznie
• dylacja zwiększa kwadratowo (wykładniczo dla większej liczby wymiarów wejściowego "obrazu") pola recepcyjnego
• większe zwrócenie uwagi na ogólne cechy
• ewentualnie także przyspieszenie pracy

Wiele kanałów

wiele kanałów wejściowych

• dla RGB konwolucje są w rzeczywistości $w\times h\times3$ dla $c_{in}=3$ (załóżmy obraz 2-wymiarowy))
  • dla każdego kanału jest osobna konwolucja $w\times h$
  • obliczane niezależnie na każdym kanale
  • na końcu sumowane w poprzek kanałów
    • o ile jest jeden kanał wyjściowy

i wiele wyjściowych

• większość modeli CNN zmniejsza wymiarowość przestrzenną, jednocześnie zwiększając liczbę kanałów (głębokość)

• kanały są wykorzystywane wspólnie

  • dla każdego z wielu kanałów wyjściowych tworzona jest konwolucja $c_{in}\times w\times h$
    • poszczególne wyniki są konkatenowane
    • w efekcie kernel jest $c_{in}\times{}c_{out}\times{}w\times{}h$
  • prosta intuicja mówiłaby, ze kanały wydobywają różne cechy
  • w rzeczywistości poszczególne kanały wykrywają wiele cech jednocześnie

• wszystkie obliczenia mogą być zrównoleglone

konwolucje 1 x 1

• najprościej patrząc konwolucja $1\times1$ oblicza korelację sąsiadujących w kanałach wektorów pikseli
  • nie wykorzystuje informacji o sąsiedztwie
  • wciąż może być wiele kanałów wyjściowych
  • zwykle po takich konwolucjach użyta jest funkcja nieliniowa

pooling

• model CNN agreguje informacje z cech niższego poziomu na bardziej ogólne
  • prostym przykładem jest składanie liter z linii, bądźmy ostrożni z tak symplicystycznym wytłumaczeniem
• potrzebny jest operator pozwalający na niezależność cech od przesunięcia

max-pooling

• w neuronaukach informacja jest agregowana w sposób hierarchiczny
• max-pooling odpowiada wyborowi najsilniejszej cechy i jest zwykle efektywniejsza od average-pooling
• jeśli kernel konwolucji ma wykrywać krawędzie, to max-pooling odpowie czy krawędź jest obecna na którymkolwiek z pól szerszego obszaru
  • obliczenia są proste z użyciem operatora max lub średniej
• pooling zmniejsza obszar
  • możemy uzyć odpowiednich padding czy stride dla utrzymania odpowiednich wymiarów
• pooling nie zmienia liczby kanałów
  • operator pooling jest aplikowany do każdego kanału osobno

average-pooling

• przypomina / jest równoważne zmniejszanie rozdzielczości obrazu
• zamiast szukania cech pomijając kolumny/wiersze, lepiej jest uśrednić znalezione cechy

Uczenie

• wszystkie parametry konwolucji są wyszukiwane w trakcie uczenia
  • zwykle standardowe uczenie wsteczną propagacją
• hiper-parametry padding, stride, dilation, pooling są ustalone
  • istnieją odmiany pooling, które są uczone, chociaż w metodach attention
• potrzeba dobrze zaprojektować model CNN
  • w sieci jest wiele kalkulatorów dla obliczania wielkości kolejnych warstw (nie, żeby to było trudne) 😩 $$out=\left\lfloor\dfrac{in + 2 * padding - (kernel - 1) - 1}{stride}\right\rfloor+1$$

LeNet

• projekt Yanna LeCun (wtedy Bell Labs, obecnie profesor na NYU, szef naukowy na Meta (nie jestem pewien czy wciąż, ale chyba zrezygnował w proteście) jeden z guru AI i sieci neuronowych w szczególności) i Leona Bottou, lata 1990...

• oryginalnie dla obrazów MNIST, $28\times28$, razem 784 pikseli

  • oryginalne obrazy miały wymiar 32 na 32, ale zostały obcięte dla oszczędności
  • LeNet został zastosowany do maszyn ATM — niektóre wciąż używają
  • poniżej 1% błędu

• bloki konwolucyjne C$_n$ z sigmoidalną aktywacją

  • C$_1$ ma 6 kanałów wyjściowych, C$_3$ ma 16
  • konwolucje 5 na 5
  • pierwsza warstwa ma w rzeczywistości padding=2, odpowiadający usuniętym pikselom
  • druga warstwa konwolucyjna nie dodaje padding

• bloki average-pooling S$_k$

  • każdy pooling o wymiarach 2 na 2, ze stride=2

• na końcu warstwy liniowe z sigmoidalną aktywacją o wielkościach 120, 84, i 10 (tyle ile cyfr)

  • oryginalnie gausowska funkcja aktywacji

• model osiąga błąd na zbiorach uczących, walidacyjnych i testowych poniżej 1% już po kilkunastu epokach

AlexNet [Krizhevsky, Sutskever, Hinton, ImageNet Classification with deep convolutional neural networks]

• ANN nie były w stanie przetwarzać dużych zbiorów i uczyć się niskopoziomowych cech
• cechy były tworzone "ręcznie" by używać linowych klasyfikatorów
• AlexNet [Krizhevsky et al., 2012] był pierwszym modelem, w którym powstało uczenie reprezentacji (representation learning)
  • zamiast projektować cechy, model uczył się istotnych dla problemu filtrów
  • dla zadań rozpoznawania obrazów są one bardzo zbieżne z filtrami Gabora
    • wykryte w układzie wzrokowym

[Krizhevsky et al]

• dane ImageNet 2009: milion obrazów - 1000 obrazów z każdej z 1000 klas zorganizowanych hierarchicznie WordNet
  • obrazy 224 na 224
  • konkurs ILSVRC
• szczęśliwie pojawiły się rozwiązania GPU dla gier komputerowych, później uogólnione
  • GPU są zwykle znacznie bardziej efektywne energetycznie
  • wykonują bardzo wiele prostych operacji równolegle
  • to jest spójne z koncepcją grafu obliczeń

Architektura AlexNet

• koncepcją było wykorzystanie GPU i zoptymalizowanie architektury dla dwóch jednostek
  • konwolucje 11 na 11 w pierwszej warstwie
  • w następnej konwolucje 5 na 5, a potem 3 na 3
  • wykorzystuje max-pooling
  • znacznie więcej kanałów niż LeNet (obrazy są zresztą kolorowe)
  • na końcu dwie warstwy FF z 4096 neuronami każda co wymaga około 1GB parametrów
  • ze względu na ograniczone zasoby użytych GPU, model został oryginalnie podzielony na dwie części
    • model był uczony na dwóch kartach Nvidia GTX 580
    • każdy procesor obsługiwał jedynie połowę neuronów
    • to pozwalało na zrównoleglenie obliczeń
    • warstwy feed-forward były też podzielone, by uniknąć zakleszczeń (bottleneck)
    • połowa wyliczonych filtrów szła do jednego GPU, pozostałe do drugiego
    • po drugiej warstwie konwolucji GPU dzieliły między sobą obliczone filtry
      • to pozwalało na obliczenia w szerszym kontekście
    • po piątej warstwie konwolucji mapy cech były rekombinowane
      • każdy GPU miał teraz dostęp do wszystkich cech dla obliczeń w warstwach feedforward
• AlexNet wykorzystał aktywację ReLU
  • znacznie prostsze obliczenia
  • zapobiega przed problemem zanikającego gradientu przy wysyconych wartościach sum
• uczenie
  • LeNet wykorzystywał jedynie weight decay
  • w AlexNet autorzy dodali bardzo wiele augmentacji danych
    • odwracanie, translacja, i obcinanie obrazu
    • modyfikacje kolorów
    • znacznie większy zbiór danych zabezpieczał przed over-fittingiem
• AlexNet wygrywając ILSVRC-2012 z dużą przewagą okazał się przełomowym rozwiązaniem przekraczając Rubikon od sieci płytkich do głębokich
  • accuracy
    • top-1 62.5%
    • top-5 83.0%
  • z jednej strony poprawienie LeNet
  • skok dzięki ReLU
  • ostatnie dwie warstwy miały $6400\times4096+4096\times4096$ parametrów!
  • wciąż jednak długo nie było powszechnie dostępnych narzędzi programistycznych

VGG net (Visual Geometry Group, Oxford) [Karen Simonyan, Andrew Zisserman 2014]

• podczas gdy AlexNet był architekturą zaprojektowaną od początku do końca, VGG był propozycją modułową z powtarzalnych bloków

  • warstwy konwolucyjnej z paddingiem dla utrzymania rozdzielczości
  • nieliniowości typu ReLU
  • pooling typu max-pooling dla redukcji rozdzielczości
    • w CNN rozdzielczość spada szybko dając ścisłe ograniczenie na liczbę warstw rzędu $\log_2 d$ gdzie $d$ jest wymiarem wejścia (dla ImageNet to daje 8 warstw konwolucyjnych)

• w VGG autorzy zaproponowali głębsze modele raczej niż szersze przez wiele kolejnych mniejszych konwolucji

  • przykładowo trzy warstwy konwolucji $3\times3$
    • dodanie paddingu 1 w każdym kierunku nie zmniejsza wymiaru
    • to daje $3\cdot9\cdot{}c^2$ parametrów
  • podczas gdy konwolucja $5\times5$ (jak w AlexNet)
    • dla niezmniejszania wymiaru konieczny padding 2
    • parametrów $25\times{}c^2$, a więc bardzo podobna liczba
  • konwolucję $7\times7$ mamy $7\times7$ można zastąpić pięcioma konwolucjami $3\times3$ o liczbie $5\times3\times3$ parametrów *też padding 1 by nie zmniejszać wymiarów
  • w każdym bloku VGG dwie warstwy konwolucyjne
    • zwykle znacznie zwiększają liczbę kanałów
    • a następnie warstwa max-pool redukująca wymiar
    • blokowa konstrukcja pozwala na budowę modelu o (prawie) dowolnej głębokości

• VGG-16 ma trochę ponad 138 milionów parametrów, AlexNet ponad 62 miliony

  | warstwa | in | out | layer | stride | kernel | param | | ---: | :--- | :--- | :--- | ---: | :--- | ---: | | 1 | 224 x 224 x 3 | 224 x 224 x 64 | conv | 1 | 3 x 3 | 1,792 | | 2 | 224 x 224 x 64 | 224 x 224 x 64 | conv | 1 | 3 x 3 | 36,928 | | | 224 x 224 x 64 | 112 x 112 x 64 | max-pool | 2 | 2 x 2 | | | 3 | 112 x 112 x 64 | 112 x 112 x 128 | conv | 1 | 3 x 3 | 73,856 | | 4 | 112 x 112 x 128 | 112 x 112 x 128 | conv | 1 | 3 x 3 | 147,584 | | | 112 x 112 x 128 | 56 x 56 x 128 | max-pool | 2 | 2 x 2 | | | 5 | 56 x 56 x 128 | 56 x 56 x 256 | conv | 1 | 3 x 3 | 295,168 | | 6 | 56 x 56 x 256 | 56 x 56 x 256 | conv | 1 | 3 x 3 | 590,080 | | 7 | 56 x 56 x 256 | 56 x 56 x 256 | conv | 1 | 3 x 3 | 590,080 | | | 56 x 56 x 256 | 28 x 28 x 256 | max-pool | 2 | 2 x 2 | | | 8 | 28 x 28 x 256 | 28 x 28 x 512 | conv | 1 | 3 x 3 | 1,180,160 | | 9 | 28 x 28 x 512 | 28 x 28 x 512 | conv | 1 | 3 x 3 | 2,359,808 | | 10 | 28 x 28 x 512 | 28 x 28 x 512 | conv | 1 | 3 x 3 | 2,359,808 | | | 28 x 28 x 512 | 14 x 14 x 512 | max-pool | 2 | 2 x 2 | | | 11 | 14 x 14 x 512 | 14 x 14 x 512 | conv | 1 | 3 x 3 | 2,359,808 | | 12 | 14 x 14 x 512 | 14 x 14 x 512 | conv | 1 | 3 x 3 | 2,359,808 | | 13 | 14 x 14 x 512 | 14 x 14 x 512 | conv | 1 | 3 x 3 | 2,359,808 | | | 14 x 14 x 512 | 7 x 7 x 512 | max-pool | 2 | 2 x 2 | | | 14 | 1 x 1 x 25088 | 1 x 1 x 4096 | feed-forward | | 1 x 1 | 102,764,544 | | 15 | 1 x 1 x 4096 | 1 x 1 x 4096 | feed-forward | | 1 x 1 | 16,781,312 | | 16 | 1 x 1 x 4096 | 1 x 1 x 1000 | feed-forward | | 1 x 1 | 4,097,000 | | | | | | | razem | 138,423,208 |

• jest wiele predefiniowanych architektur VGGNet umożliwiających pewne zrównoważenie między jakością a złożonością

• możliwe, że sieci płytsze, ale szersze pozwalają na podobną jakość przy szybszym uczeniu

• VGGNet wciąż ma warstwy feed-forward na końcu, które mają olbrzymią liczbę parametrów

Czy możliwa jest optymalizacja tych architektur? network-in-network [Lin, Chen, Yan, Network in network, 2013]

• wszystkie mają warstwy feed-forward z olbrzymią liczbą parametrów
  • taka warstwa jest olbrzymią macierzą trudną do przetwarzania na mniejszych urządzeniach
• propozycja uproszczenia
  • użycie konwolucji $1\times1$ dla dodania lokalnych nieliniowości
  • dodanie average-pooling na samym końcu
• architektura (https://arxiv.org/pdf/1312.4400.pdf) wykorzystuje blok zastępujący blok w VGG
  • konwolucja $k\times{}k$ - typowe konwolucje zbierające informacje przestrzenne
  • konwolucja $1\times1$ - zbiera informacje z wielu miejsc, wynikające z poprzedniej konwolucji, w wiele wymiarów
  • konwolucja $1\times1$
  • bloki VGG w dalszym ciągu używały, też niezmieniających wymiaru, konwolucji $3\times3$
• w kolejnych blokach NiN konwolucje
  • $11\times11$ ze stride 4, 96 kanałów
  • $5\times5$ z paddingiem 2, 256 kanałów
  • $3\times3$ z paddingiem 1, 384 kanały
  • $3\times3$ z paddingiem 1, 10 kanałami (tyle ile klas wyjściowych)
  • bez warstw feed-forward na końcu
  • na końcu każdy kanał jest uśredniony przez average pooling
    • aby ta operacja miała sens, konieczne są konwolucje $1\times1$
• konwolucje $1\times1$
  • operują na pojedynczych pikselach
  • można traktować jako wielowymiarowe warstwy feed-forward uczone na pojedynczych pikselach obrazu
• ta budowa znacznie zmniejsza liczbę uczonych parametrów
  • ten model trochę idzie w szerokość poprzez konwolucje na początku
  • jednocześnie w głębokość przez konwolucje $1\times1$
• liczba parametrów w VGG vs NiN
  • VGG 16/19 134 / 144 miliony
  • NiN 7 / 8 milionów

Wszystko razem: różne wymiary konwolucji, konwolucje $1\times1$, bloki, ale też rozwarstwienia [Szegedy, Going deeper with convolutions, 2014]

• konwolucje przetwarzają obraz na różnych poziomach łącząc wyniki

  • zwykle badacze szukają optymalnej konwolucji dla problemu, albo ustalają stałą, np. VGG
    • każdy problem ma inne wymagania
    • rozpoznawanie jest zależne od tego, jaką frakcję całego wejścia (obrazu) zajmuje istotna informacja
    • zbyt głębokie sieci mają skłonność do zbytniego dopasowania (overfitting)

• konwolucje $1\times1$ pozwalają na zwiększenie wymiarowości dodając nieliniowości stosunkowo niskim kosztem

  • GoogLeNet po prostu konkatenuje wyniki!
  • oryginalne rozwiązanie dodawało dodatkowe funkcje pośrednie dla zwiększenia stabilności uczenia w złożonej architekturze
  • nowe algorytmy uczące, wraz z normalizacją (BatchNorm) pozwoliły na uniknięcie
  • konwolucje używają odpowiednich paddingów dla utrzymania wymiarów by móc konkatenować wyniki

---

Inception v1

• model jest głęboki (22 poziomy konwolucji) powodując zanikanie gradientów w środkowej części
  • dodatkowe dwa poziomy klasyfikacyjne - softmax do pośrednich wyników - w środkowej części
  • całkowita wartość loss jako suma ważona (zwykle z wagą $\sim0.3$ dla każdego wyjścia)

---

Inception v2

• konwolucje o większych wymiarach za szybko zmniejszają wymiar, powodując wąskie gardło informacyjne (ang. information bottleneck), jednocześnie spowalniając
  • faktoryzacja konwolucji $5\times5$ na dwie konwolucje $3\times3$
    • efektywniejsze — prawie 3 razy szybsze obliczenia
  • zamiana konwolucji $n\times{}n$ na sekwencję konwolucji $n\times1$ oraz $1\times{}n$, co dla konwolucji $3\times3$ okazuje się o jedną trzecią szybsze!
  • także banki filtrów: zamiast sekwencji $3\times1$ oraz $1\times3$ zrobić równolegle $n\times1$ oraz $1\times{}n$ a następnie konkatenować wyniki

---

Inception v3

• dodatkowe klasyfikatory pośrodku pnia Inception w niewiele dają
  • uczenie poprawia się dopiero gdy osiągana klasyfikacja jest prawie pewna (saturacja)
    • konieczna regularyzacja pośrednich klasyfikatorów
  • modyfikacja Inception v2 przez
    • zmianę uczenia na RMSProp
    • faktoryzację konwolucji $7\times7$
    • dodanie BatchNorm w pośrednich klasyfikatorach
    • regularyzacja przez wygładzanie etykiet [Muller, Kornblith, Hinton, When does label smoothing help?, 2019]
      • jeśli etykiety są nieprawidłowe, to maksymalizacja $p(y\mid x)$ może być szkodliwa
      • założenie, że dostępna etykieta jest prawdziwa z prawdopodobieństwem $1-\epsilon$
      • zamiana etykiet $0, 1$ na $\dfrac{\epsilon}{k-1}, 1-\epsilon$ dla wektora wyjściowego one-hot o $k$ składnikach
        • po modyfikacji wciąż sumuje się do 1

---

Inception v4

• architektura jest wciąż zbyt skomplikowana - zunifikować bloki
  • wersja 4 wprowadza 3 typy bloków A, B, i C
  • bloki są zaimportowane z poprzednich wersji
• zmodyfikować początkowy korzeń drzewa (stem)
  • początkowe przetwarzanie w korzeniu okazywało się bardzo istotne we wszystkich wersjach

• dodatkowo wprowadzone bloki redukcji
  • pozwalają na zmianę wymiarów explicite

Liczba uczonych parametrów

• Inception ma znacznie mniejszą liczbę parametrów do uczenia

Porównanie wyników

• dla porównanie musimy wziąć pod uwagę liczbę parametrów, jak długo model trzeba liczyć, oraz skuteczność
  • Top-1 to frakcja przykładów, które model poprawnie sklasyfikował
  • Top-5 to frakcja przykładów, gdy prawdziwa klasa była wśród pięciu najbardziej prawdopodobnych

Porównanie wszelkich modeli dla ImageNet

ImageNet modele GFlops

ImageNet modele top-1